/**
 * Upbit 交易对监控系统 - 主应用入口
 * 
 * 功能：
 * - 监控 Upbit 交易所交易对变化
 * - 发现新增交易对时发送邮件通知
 * - 持久化存储交易对数据
 * - 完善的错误处理和日志记录
 */

require('dotenv').config();
const TradingPairMonitor = require('./monitors/tradingPairMonitor');
const StatusMonitor = require('./monitors/statusMonitor');
const logger = require('./utils/logger');
const cron = require('node-cron');
const path = require('path');
const AutoUpdater = require('../scripts/auto-update');

class App {
  constructor() {
    this.monitor = new TradingPairMonitor();
    this.statusMonitor = new StatusMonitor();
    this.dailyTask = null;
    this.autoUpdateTask = null;
    this.setupSignalHandlers();
  }

  /**
   * 启动应用
   */
  async start() {
    try {
      logger.info('🚀 Upbit 交易对监控系统启动中...');
      
      // 初始化监控器
      await this.monitor.initialize();
      await this.statusMonitor.initialize();
      
      // 开始监控
      this.monitor.start();
      
      // 检查是否启用状态监控
      const enableStatusMonitor = process.env.ENABLE_STATUS_MONITOR !== 'false';
      if (enableStatusMonitor) {
        this.statusMonitor.start();
      } else {
        logger.info('📊 交易对状态监控已禁用');
      }
      
      // 设置定时任务
      this.setupScheduledTasks();
      
      // 显示状态信息
      this.displayStatus();
      
    } catch (error) {
      logger.error(`应用启动失败: ${error.message}`);
      process.exit(1);
    }
  }

  /**
   * 停止应用
   */
  async stop() {
    logger.info('👋 正在停止监控系统...');
    
    try {
      // 停止定时任务
      if (this.dailyTask) {
        this.dailyTask.destroy();
        logger.info('📅 日报定时任务已停止');
      }
      
      if (this.autoUpdateTask) {
        this.autoUpdateTask.destroy();
        logger.info('🔄 自动更新任务已停止');
      }
      
      // 停止监控器
      this.monitor.stop();
      this.statusMonitor.stop();
      logger.success('监控系统已安全停止');
    } catch (error) {
      logger.error(`停止监控系统时出错: ${error.message}`);
    }
    
    process.exit(0);
  }

  /**
   * 显示系统状态
   */
  displayStatus() {
    const status = this.monitor.getStatus();
    
    logger.info('📊 系统状态信息:');
    logger.info(`   运行状态: ${status.isRunning ? '✅ 运行中' : '❌ 已停止'}`);
    logger.debug(`   检查间隔: ${status.checkInterval / 1000} 秒`);
    logger.debug(`   邮件接收者: ${status.recipients.length} 位`);
    logger.debug(`   数据文件: ${status.dataFilePath}`);
    logger.info(`   日报任务: ${this.dailyTask ? '✅ 每日上午9点发送汇总报告' : '❌ 未启用'}`);
    logger.info(`   自动更新: ${this.autoUpdateTask ? '✅ 每2小时检查Git更新' : '❌ 未启用'}`);
    logger.info(`   状态监控: ${this.statusMonitor.isRunning ? '✅ USDT交易对状态监控已启用' : '❌ 未启用'}`);
    logger.info('💡 使用 Ctrl+C 可以安全退出程序');
  }

  /**
   * 设置定时任务
   */
  setupScheduledTasks() {
    try {
      // 每天上午9点发送日报邮件
      // 格式: 秒 分 时 日 月 星期
      this.dailyTask = cron.schedule('0 0 9 * * *', async () => {
        logger.info('📅 定时任务触发：开始发送日报邮件');
        try {
          const emailService = this.monitor.emailService;
          const success = await emailService.sendDailySummaryEmail();
          if (success) {
            logger.success('📊 日报邮件发送完成');
          } else {
            logger.error('📊 日报邮件发送失败');
          }
        } catch (error) {
          logger.error(`定时任务执行失败: ${error.message}`);
        }
      }, {
        scheduled: true,
        timezone: "Asia/Shanghai"
      });

      logger.success('📅 定时任务设置成功：每日上午9点发送汇总报告');
      
      // 计算下次执行时间（每日上午9点）
      const now = new Date();
      const nextRun = new Date(now);
      nextRun.setHours(9, 0, 0, 0);
      
      // 如果今天9点已过，设置为明天9点
      if (nextRun <= now) {
        nextRun.setDate(nextRun.getDate() + 1);
      }
      
      logger.debug(`📅 下次执行时间: ${nextRun.toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai' })}`)
      
      // 设置自动更新任务（每2小时执行一次）
      // 格式: 秒 分 时 日 月 星期
      const enableAutoUpdate = process.env.ENABLE_AUTO_UPDATE !== 'false';
      
      if (enableAutoUpdate) {
        this.autoUpdateTask = cron.schedule('0 0 */2 * * *', async () => {
          logger.info('🔄 自动更新任务触发：检查Git更新');
          try {
            const updater = new AutoUpdater();
            const result = await updater.run();
            
            if (result.updated) {
              logger.success(`🎉 自动更新完成: ${result.message}`);
            } else if (result.error) {
              logger.error(`❌ 自动更新失败: ${result.message}`);
            } else {
              logger.debug(`📄 自动更新检查: ${result.message}`);
            }
          } catch (error) {
            logger.error(`自动更新任务执行失败: ${error.message}`);
          }
        }, {
          scheduled: true,
          timezone: "Asia/Shanghai"
        });
        
        logger.success('🔄 自动更新任务设置成功：每2小时检查Git更新');
        logger.debug('💡 可通过设置 ENABLE_AUTO_UPDATE=false 禁用自动更新');
      } else {
        logger.info('🔄 自动更新功能已禁用');
      }
      
    } catch (error) {
      logger.error(`定时任务设置失败: ${error.message}`);
      logger.warn('将继续运行其他功能，但定时任务可能不可用');
    }
  }

  /**
   * 手动触发日报发送（用于测试）
   */
  async triggerDailySummary() {
    logger.info('🔍 手动触发日报发送...');
    try {
      const emailService = this.monitor.emailService;
      const success = await emailService.sendDailySummaryEmail();
      if (success) {
        logger.success('📊 日报邮件发送完成');
      } else {
        logger.error('📊 日报邮件发送失败');
      }
      return success;
    } catch (error) {
      logger.error(`手动发送日报失败: ${error.message}`);
      return false;
    }
  }

  /**
   * 手动触发状态检查（用于测试）
   */
  async triggerStatusCheck() {
    logger.info('🔍 手动触发状态检查...');
    try {
      const result = await this.statusMonitor.triggerCheck();
      
      if (result.success) {
        logger.success(`✅ 状态检查完成: ${result.message}`);
      } else {
        logger.error(`❌ 状态检查失败: ${result.message || result.error}`);
      }
      
      return result;
    } catch (error) {
      logger.error(`手动状态检查失败: ${error.message}`);
      return { success: false, error: error.message };
    }
  }

  /**
   * 手动触发自动更新（用于测试）
   */
  async triggerAutoUpdate() {
    logger.info('🔄 手动触发自动更新检查...');
    try {
      const updater = new AutoUpdater();
      const result = await updater.run();
      
      if (result.updated) {
        logger.success(`🎉 更新完成: ${result.message}`);
      } else if (result.error) {
        logger.error(`❌ 更新失败: ${result.message}`);
      } else {
        logger.info(`📄 检查结果: ${result.message}`);
      }
      
      return result;
    } catch (error) {
      logger.error(`手动更新检查失败: ${error.message}`);
      return { updated: false, error: true, message: error.message };
    }
  }

  /**
   * 设置信号处理器
   */
  setupSignalHandlers() {
    // 处理 Ctrl+C (SIGINT)
    process.on('SIGINT', () => {
      logger.info('');
      logger.info('收到退出信号 (SIGINT)');
      this.stop();
    });

    // 处理 SIGTERM
    process.on('SIGTERM', () => {
      logger.info('收到终止信号 (SIGTERM)');
      this.stop();
    });

    // 处理未捕获的异常
    process.on('uncaughtException', (error) => {
      logger.error(`未捕获的异常: ${error.message}`);
      logger.error(error.stack);
      this.stop();
    });

    // 处理未处理的 Promise 拒绝
    process.on('unhandledRejection', (reason, promise) => {
      logger.error(`未处理的 Promise 拒绝: ${reason}`);
      logger.error(`Promise: ${promise}`);
      this.stop();
    });
  }
}

// 创建并启动应用
const app = new App();
app.start();
